home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / isave.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-02  |  30.0 KB  |  988 lines
  1. /* Copyright (C) 1993, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* isave.c */
  20. /* Save/restore manager for Ghostscript interpreter */
  21. #include "ghost.h"
  22. #include "memory_.h"
  23. #include "errors.h"
  24. #include "gsexit.h"
  25. #include "gsstruct.h"
  26. #include "iastate.h"
  27. #include "inamedef.h"
  28. #include "ipacked.h"
  29. #include "isave.h"
  30. #include "isstate.h"
  31. #include "store.h"            /* for ref_assign */
  32. #include "ivmspace.h"
  33. #include "gsutil.h"            /* gs_next_ids prototype */
  34.  
  35. /* Imported restore routines */
  36. extern void file_save(P0());
  37. extern void file_restore(P2(const alloc_save_t *, const gs_memory_t *));
  38. extern void file_forget_save(P1(const alloc_save_t *));
  39. extern void font_restore(P1(const alloc_save_t *));
  40.  
  41. /* Structure descriptor */
  42. private_st_alloc_save();
  43.  
  44. /* Define the maximum amount of data we are willing to scan repeatedly -- */
  45. /* see below for details. */
  46. private const long max_repeated_scan = 100000;
  47.  
  48. /* Some compilers try to substitute macro args in string literals! */
  49. #define print_save(str, spacen, sav)\
  50.   if_debug5('u', "[u]%s space %u 0x%lx: cdata = 0x%lx, id = %lu\n",\
  51.     str, spacen, (ulong)(sav), (ulong)(sav)->client_data, (ulong)(sav)->id);
  52.  
  53. /*
  54.  * The logic for saving and restoring the state is complex.
  55.  * Both the changes to individual objects, and the overall state
  56.  * of the memory manager, must be saved and restored.
  57.  */
  58.  
  59. /*
  60.  * To save the state of the memory manager:
  61.  *    Save the state of the current chunk in which we are allocating.
  62.  *    Shrink the current chunk to its inner unallocated region.
  63.  *    Save and reset the free block chains.
  64.  * By doing this, we guarantee that no object older than the save
  65.  * can be freed.
  66.  *
  67.  * To restore the state of the memory manager:
  68.  *    Free all chunks newer than the save, and the descriptor for
  69.  *      the inner chunk created by the save.
  70.  *    Make current the chunk that was current at the time of the save.
  71.  *    Restore the state of the current chunk.
  72.  *
  73.  * In addition to save ("start transaction") and restore ("abort transaction"),
  74.  * we support forgetting a save ("commit transation").  To forget a save:
  75.  *    Reassign to the next outer save all chunks newer than the save.
  76.  *    Free the descriptor for the inner chunk, updating its outer chunk
  77.  *      to reflect additional allocations in the inner chunk.
  78.  *    Concatenate the free block chains with those of the outer save.
  79.  */
  80.  
  81. /*
  82.  * For saving changes to individual objects, we add an "attribute" bit
  83.  * (l_new) that logically belongs to the slot where the ref is stored,
  84.  * not to the ref itself.  The bit means "the contents of this slot
  85.  * have been changed, or the slot was allocated, since the last save."
  86.  * To keep track of changes since the save, we associate a chain of
  87.  * <slot, old_contents> pairs that remembers the old contents of slots.
  88.  *
  89.  * When creating an object, if the save level is non-zero:
  90.  *    Set l_new in all slots.
  91.  *
  92.  * When storing into a slot, if the save level is non-zero:
  93.  *    If l_new isn't set, save the address and contents of the slot
  94.  *      on the current contents chain.
  95.  *    Set l_new after storing the new value.
  96.  *
  97.  * To do a save:
  98.  *    If the save level is non-zero:
  99.  *        Reset l_new in all slots on the contents chain, and in all
  100.  *          objects created since the previous save.
  101.  *    Push the head of the contents chain, and reset the chain to empty.
  102.  *
  103.  * To do a restore:
  104.  *    Check all the stacks to make sure they don't contain references
  105.  *      to objects created since the save.
  106.  *    Restore all the slots on the contents chain.
  107.  *    Pop the contents chain head.
  108.  *    If the save level is now non-zero:
  109.  *        Scan the newly restored contents chain, and set l_new in all
  110.  *          the slots it references.
  111.  *        Scan all objects created since the previous save, and set
  112.  *          l_new in all the slots of each object.
  113.  *
  114.  * To forget a save:
  115.  *    If the save level is greater than 1:
  116.  *        Set l_new as for a restore, per the next outer save.
  117.  *        Concatenate the next outer contents chain to the end of
  118.  *          the current one.
  119.  *    If the save level is 1:
  120.  *        Reset l_new as for a save.
  121.  *        Free the contents chain.
  122.  */
  123.  
  124. /*
  125.  * A consequence of the foregoing algorithms is that the cost of a save
  126.  * is proportional to the total amount of data allocated since the previous
  127.  * save.  If a PostScript program reads in a large amount of setup code
  128.  * and then uses save/restore heavily, each save/restore will be expensive.
  129.  * To mitigate this, we check to see how much data we are scanning at a save;
  130.  * if it is large, we do a second, invisible save.  This greatly reduces
  131.  * the cost of inner saves, at the expense of possibly saving some changes
  132.  * twice that otherwise would only have to be saved once.
  133.  */
  134.  
  135. /*
  136.  * The presence of global and local VM complicates the situation further.
  137.  * There is a separate save chain and contents chain for each VM space.
  138.  * When multiple contexts are fully implemented, save and restore will have
  139.  * the following effects, according to the privacy status of the current
  140.  * context's global and local VM:
  141.  *    Private global, private local:
  142.  *        The outermost save saves both global and local VM;
  143.  *          otherwise, save only saves local VM.
  144.  *    Shared global, private local:
  145.  *        Save only saves local VM.
  146.  *    Shared global, shared local:
  147.  *        Save only saves local VM, and suspends all other contexts
  148.  *          sharing the same local VM until the matching restore.
  149.  * Since we do not currently implement multiple contexts, only the first
  150.  * case is relevant.
  151.  *
  152.  * Note that when saving the contents of a slot, the choice of chain
  153.  * is determined by the VM space in which the slot is allocated,
  154.  * not by the current allocation mode.
  155.  */
  156.  
  157. #define set_in_save(dmem)\
  158.   ((dmem)->test_mask = (dmem)->new_mask = l_new)
  159. #define set_not_in_save(dmem)\
  160.   ((dmem)->test_mask = ~0, (dmem)->new_mask = 0)
  161.  
  162. /*
  163.  * Structure for saved change chain for save/restore.  Because of the
  164.  * garbage collector, we need to distinguish the cases where the change
  165.  * is in a static object, a dynamic ref, or a dynamic struct.
  166.  */
  167. typedef struct alloc_change_s alloc_change_t;
  168. struct alloc_change_s {
  169.     alloc_change_t *next;
  170.     ref_packed *where;
  171.     ref contents;
  172. #define ac_offset_static (-2)    /* static object */
  173. #define ac_offset_ref (-1)    /* dynamic ref */
  174.     short offset;    /* if >= 0, offset within struct */
  175. };
  176. #define ptr ((alloc_change_t *)vptr)
  177. private CLEAR_MARKS_PROC(change_clear_marks) {
  178.     if ( r_is_packed(&ptr->contents) )
  179.       r_clear_pmark((ref_packed *)&ptr->contents);
  180.     else
  181.       r_clear_attrs(&ptr->contents, l_mark);
  182. }
  183. private ENUM_PTRS_BEGIN(change_enum_ptrs) return 0;
  184.     ENUM_PTR(0, alloc_change_t, next);
  185.     case 1:
  186.         if ( ptr->offset >= 0 )
  187.           {    *pep = (byte *)ptr->where - ptr->offset;
  188.             return ptr_struct_type;
  189.           }
  190.         else
  191.           {    *pep = ptr->where;
  192.             return ptr_ref_type;
  193.           }
  194.     case 2:
  195.         *pep = &ptr->contents;
  196.         return ptr_ref_type;
  197. ENUM_PTRS_END
  198. private RELOC_PTRS_BEGIN(change_reloc_ptrs) {
  199.     RELOC_PTR(alloc_change_t, next);
  200.     switch ( ptr->offset )
  201.       {
  202.       case ac_offset_static:
  203.         break;
  204.       case ac_offset_ref:
  205.         ptr->where = gs_reloc_ref_ptr(ptr->where, gcst);
  206.         break;
  207.       default:
  208.         {    byte *obj = (byte *)ptr->where - ptr->offset;
  209.         byte *robj = gs_reloc_struct_ptr(obj, gcst);
  210.         ptr->where = (ref_packed *)(robj + ptr->offset);
  211.         }    break;
  212.       }
  213.     if ( r_is_packed(&ptr->contents) )
  214.       r_clear_pmark((ref_packed *)&ptr->contents);
  215.     else
  216.       { gs_reloc_refs((ref_packed *)&ptr->contents,
  217.               (ref_packed *)(&ptr->contents + 1),
  218.               gcst);
  219.         r_clear_attrs(&ptr->contents, l_mark);
  220.       }
  221. } RELOC_PTRS_END
  222. #undef ptr
  223. gs_private_st_complex_only(st_alloc_change, alloc_change_t, "alloc_change",
  224.   change_clear_marks, change_enum_ptrs, change_reloc_ptrs, 0);
  225.  
  226. /* Debugging printout */
  227. #ifdef DEBUG
  228. private void
  229. alloc_save_print(alloc_change_t *cp, bool print_current)
  230. {    dprintf2(" 0x%lx: 0x%lx: ", (ulong)cp, (ulong)cp->where);
  231.     if ( r_is_packed(&cp->contents) )
  232.       { if ( print_current )
  233.           dprintf2("saved=%x cur=%x\n", *(ref_packed *)&cp->contents,
  234.                *cp->where);
  235.         else
  236.           dprintf1("%x\n", *(ref_packed *)&cp->contents);
  237.       }
  238.     else
  239.       { if ( print_current )
  240.           dprintf6("saved=%x %x %lx cur=%x %x %lx\n",
  241.                r_type_attrs(&cp->contents), r_size(&cp->contents),
  242.                (ulong)cp->contents.value.intval,
  243.                r_type_attrs((ref *)cp->where),
  244.                r_size((ref *)cp->where),
  245.                (ulong)((ref *)cp->where)->value.intval);
  246.         else
  247.           dprintf3("%x %x %lx\n",
  248.                r_type_attrs(&cp->contents), r_size(&cp->contents),
  249.                (ulong)cp->contents.value.intval);
  250.       }
  251. }
  252. #endif
  253.  
  254. /* Forward references */
  255. private void restore_resources(P2(alloc_save_t *, gs_ref_memory_t *));
  256. private void restore_free(P1(gs_ref_memory_t *));
  257. private long save_set_new(P2(gs_ref_memory_t *, bool));
  258. private void save_set_new_changes(P2(gs_ref_memory_t *, bool));
  259.  
  260. /* Initialize the save/restore machinery. */
  261. void
  262. alloc_save_init(gs_dual_memory_t *dmem)
  263. {    dmem->save_level = 0;
  264.     set_not_in_save(dmem);
  265. }
  266.  
  267. /* Save the state. */
  268. private alloc_save_t *alloc_save_space(P2(gs_ref_memory_t *,
  269.                       gs_dual_memory_t *));
  270. ulong
  271. alloc_save_state(gs_dual_memory_t *dmem, void *cdata)
  272. {    gs_ref_memory_t *lmem = dmem->space_local;
  273.     gs_ref_memory_t *gmem = dmem->space_global;
  274.     ulong sid = gs_next_ids(2);
  275. #define alloc_free_save(mem, s, scn, icn)\
  276.   { chunk_t *inner = (mem)->pcc;\
  277.     gs_free_object((gs_memory_t *)(mem), s, scn);\
  278.     gs_free_object((mem)->parent, inner, icn);\
  279.   }
  280.     bool global =
  281.         dmem->save_level == 0 && gmem != lmem &&
  282.         gmem->num_contexts == 1;
  283.     alloc_save_t *gsave =
  284.       (global ? alloc_save_space(gmem, dmem) : (alloc_save_t *)0);
  285.     alloc_save_t *lsave = alloc_save_space(lmem, dmem);
  286.  
  287.     if ( lsave == 0 || (global && gsave == 0) )
  288.     {    if ( lsave != 0 )
  289.           alloc_free_save(lmem, lsave, "alloc_save_state(local save)",
  290.                   "alloc_save_state(local inner)");
  291.         if ( gsave != 0 )
  292.           alloc_free_save(gmem, gsave, "alloc_save_state(global save)",
  293.                   "alloc_save_state(global inner)");
  294.         return 0;
  295.     }
  296. #undef alloc_free_save
  297.     if ( gsave != 0 )
  298.       { gsave->id = sid + 1;
  299.         gsave->client_data = 0;
  300.         print_save("save", gmem->space, gsave);
  301.         /* Restore names when we do the local restore. */
  302.         lsave->restore_names = gsave->restore_names;
  303.         gsave->restore_names = false;
  304.       }
  305.     lsave->id = sid;
  306.     lsave->client_data = cdata;
  307.     print_save("save", lmem->space, lsave);
  308.     /* Reset the l_new attribute in all slots.  The only slots that */
  309.     /* can have the attribute set are the ones on the changes chain, */
  310.     /* and ones in objects allocated since the last save. */
  311.     if ( dmem->save_level != 0 )
  312.       {    long scanned = save_set_new(&lsave->state, false);
  313.         if ( scanned > max_repeated_scan )
  314.           {    /* Do a second, invisible save. */
  315.             alloc_save_t *rsave;
  316.             /* Notify the file machinery of the first save. */
  317.             file_save();
  318.             rsave = alloc_save_space(lmem, dmem);
  319.             if ( rsave != 0 )
  320.               {    rsave->id = sid;
  321.                 rsave->client_data = cdata;
  322.                 print_save("save", lmem->space, rsave);
  323.                 lsave->id = 0;    /* mark as invisible */
  324.                 lsave->client_data = 0;
  325.                 /* Inherit the allocated space count -- */
  326.                 /* we need this for triggering a GC. */
  327.                 rsave->state.inherited =
  328.                   lsave->state.allocated +
  329.                   lsave->state.inherited;
  330.                 lmem->inherited = rsave->state.inherited;
  331.                 print_save("save", lmem->space, lsave);
  332.               }
  333.           }
  334.       }
  335.     dmem->save_level++;
  336.     set_in_save(dmem);
  337.     /* Notify the file machinery we just did a save. */
  338.     file_save();
  339.     return sid;
  340. }
  341. /* Save the state of one space (global or local). */
  342. private alloc_save_t *
  343. alloc_save_space(gs_ref_memory_t *mem, gs_dual_memory_t *dmem)
  344. {    gs_ref_memory_t save_mem;
  345.     alloc_save_t *save;
  346.     chunk_t *inner = 0;
  347.  
  348.     if ( mem->cc.ctop - mem->cc.cbot > sizeof(chunk_head_t) )
  349.       {    inner = gs_alloc_struct(mem->parent, chunk_t, &st_chunk,
  350.                     "alloc_save_space(inner)");
  351.         if ( inner == 0 )
  352.           return 0;
  353.       }
  354.     save_mem = *mem;
  355.     alloc_close_chunk(mem);
  356.     gs_memory_status((gs_memory_t *)mem, &mem->previous_status);
  357.     ialloc_reset(mem);
  358.     mem->cc.cnext = mem->cc.cprev = 0;
  359.     if ( inner != 0 )
  360.       {    /* Create an inner chunk to cover only the unallocated part. */
  361.         alloc_init_chunk(&mem->cc, mem->cc.cbot, mem->cc.ctop,
  362.                  true, mem->pcc);
  363.         *inner = mem->cc;
  364.         mem->pcc = inner;
  365.         mem->cfirst = mem->clast = inner;
  366.       }
  367.     else
  368.       {    /* Not enough room to create an inner chunk. */
  369.         mem->pcc = 0;
  370.         mem->cfirst = mem->clast = 0;
  371.         mem->cc.cbot = mem->cc.ctop = 0;
  372.       }
  373.     save = gs_alloc_struct((gs_memory_t *)mem, alloc_save_t,
  374.                    &st_alloc_save, "alloc_save_space(save)");
  375. #ifdef DEBUG
  376.     if ( inner != 0 )
  377.       {    if_debug4('u',
  378.               "[u]save space %u at 0x%lx: cbot=0x%lx ctop=0x%lx\n",
  379.               mem->space, (ulong)save,
  380.               (ulong)inner->cbot, (ulong)inner->ctop);
  381.       }
  382.     else
  383.       {    if_debug2('u',
  384.               "[u]save space %u at 0x%lx (no inner)\n",
  385.               mem->space, (ulong)save);
  386.       }
  387. #endif
  388.     if ( save == 0 )
  389.       { gs_free_object(mem->parent, inner, "alloc_save_space(inner)");
  390.         *mem = save_mem;
  391.         return 0;
  392.       }
  393.     save->state = save_mem;
  394.     save->dmem = dmem;
  395.     save->restore_names = (name_memory() == (gs_memory_t *)mem);
  396.     save->is_current = (dmem->current == mem);
  397.     mem->saved = save;
  398.     return save;
  399. }
  400.  
  401. /* Record a state change that must be undone for restore, */
  402. /* and mark it as having been saved. */
  403. int
  404. alloc_save_change(gs_dual_memory_t *dmem, const ref *pcont,
  405.   ref_packed *where, client_name_t cname)
  406. {    gs_ref_memory_t *mem;
  407.     register alloc_change_t *cp;
  408.     if ( dmem->save_level == 0 )
  409.       return 0;    /* no saving */
  410.     mem = (pcont == NULL ? dmem->space_local :
  411.            dmem->spaces.indexed[r_space(pcont) >> r_space_shift]);
  412.     cp = gs_alloc_struct((gs_memory_t *)mem, alloc_change_t,
  413.                  &st_alloc_change, "alloc_save_change");
  414.     if ( cp == 0 )
  415.       return -1;
  416.     cp->next = mem->changes;
  417.     cp->where = where;
  418.     if ( pcont == NULL )
  419.       cp->offset = ac_offset_static;
  420.     else if ( r_is_array(pcont) || r_has_type(pcont, t_dictionary) )
  421.       cp->offset = ac_offset_ref;
  422.     else if ( r_is_struct(pcont) )
  423.       cp->offset = (byte *)where - (byte *)pcont->value.pstruct;
  424.     else
  425.       { lprintf3("Bad type %u for save!  pcont = 0x%lx, where = 0x%lx\n",
  426.              r_type(pcont), (ulong)pcont, (ulong)where);
  427.         gs_abort();
  428.       }
  429.     if ( r_is_packed(where) )
  430.       *(ref_packed *)&cp->contents = *where;
  431.     else
  432.       { ref_assign_inline(&cp->contents, (ref *)where);
  433.         r_set_attrs((ref *)where, l_new);
  434.       }
  435.     mem->changes = cp;
  436. #ifdef DEBUG
  437. if ( gs_debug_c('U') )
  438.     {    dprintf1("[u]save(%s)", client_name_string(cname));
  439.         alloc_save_print(cp, false);
  440.     }
  441. #endif
  442.     return 0;
  443. }
  444.  
  445. /* Return the current save level */
  446. int
  447. alloc_save_level(const gs_dual_memory_t *dmem)
  448. {    return dmem->save_level;
  449. }
  450.  
  451. /* Return the innermost externally visible save object, i.e., */
  452. /* the innermost save with a non-zero ID. */
  453. alloc_save_t *
  454. alloc_save_current(const gs_dual_memory_t *dmem)
  455. {    alloc_save_t *save = dmem->space_local->saved;
  456.     while ( save != 0 && save->id == 0 )
  457.       save = save->state.saved;
  458.     return save;
  459. }
  460.  
  461. /* Test whether a reference would be invalidated by a restore. */
  462. bool
  463. alloc_is_since_save(const void *vptr, const alloc_save_t *save)
  464. {
  465. #define ptr ((const char *)vptr)
  466.  
  467.     /* A reference postdates a save iff it is in a chunk allocated */
  468.     /* since the save (including the carried-over inner chunk). */
  469.  
  470.     const gs_dual_memory_t *dmem = save->dmem;
  471.     register const gs_ref_memory_t *mem = dmem->space_local;
  472.  
  473.     if_debug2('U', "[U]is_since_save 0x%lx, 0x%lx:\n",
  474.           (ulong)ptr, (ulong)save);
  475.     if ( mem->saved == 0 )
  476.     {    /* This is a special case, the final 'restore' from */
  477.         /* alloc_restore_all. */
  478.         return true;
  479.     }
  480.  
  481.     /* Check against chunks allocated since the save. */
  482.     /* (There may have been intermediate saves as well.) */
  483.     for ( ; ; mem = &mem->saved->state )
  484.     {    const chunk_t *cp;
  485.         if_debug1('U', "[U]checking mem=0x%lx\n", (ulong)mem);
  486.         for ( cp = mem->cfirst; cp != 0; cp = cp->cnext )
  487.         { if ( ptr_is_within_chunk(ptr, cp) )
  488.             {    if_debug3('U', "[U+]in new chunk 0x%lx: 0x%lx, 0x%lx\n",
  489.                   (ulong)cp,
  490.                   (ulong)cp->cbase, (ulong)cp->cend);
  491.             return true;
  492.             }
  493.           if_debug1('U', "[U-]not in 0x%lx\n", (ulong)cp);
  494.         }
  495.         if ( mem->saved == save )
  496.         {    /* We've checked all the more recent saves, */
  497.             /* must be OK. */
  498.             break;
  499.         }
  500.     }
  501.  
  502.     /* If we're about to do a global restore (save level = 1), */
  503.     /* we also have to check the global save. */
  504.     /* Global saves can't be nested, which makes things easy. */
  505.     if ( dmem->save_level == 1 &&
  506.          (mem = dmem->space_global) != dmem->space_local
  507.        )
  508.     {    const chunk_t *cp;
  509.         if_debug1('U', "[U]checking global mem=0x%lx\n", (ulong)mem);
  510.         for ( cp = mem->cfirst; cp != 0; cp = cp->cnext )
  511.           if ( ptr_is_within_chunk(ptr, cp) )
  512.             {    if_debug3('U', "[U+]  new chunk 0x%lx: 0x%lx, 0x%lx\n",
  513.                   (ulong)cp, (ulong)cp->cbase, (ulong)cp->cend);
  514.             return true;
  515.             }
  516.     }
  517.  
  518.     return false;
  519.  
  520. #undef ptr
  521. }
  522.  
  523. /* Test whether a name would be invalidated by a restore. */
  524. bool
  525. alloc_name_is_since_save(const ref *pnref, const alloc_save_t *save)
  526. {    const name *pname;
  527.     if ( !save->restore_names )
  528.       return false;
  529.     pname = pnref->value.pname;
  530.     if ( pname->foreign_string )
  531.       return false;
  532.     return alloc_is_since_save(pname->string_bytes, save);
  533. }
  534. bool
  535. alloc_name_index_is_since_save(uint nidx, const alloc_save_t *save)
  536. {    ref nref;
  537.     nref.value.pname = name_index_ptr(nidx);
  538.     return alloc_name_is_since_save(&nref, save);
  539. }
  540.  
  541. /* Check whether any names have been created since a given save */
  542. /* that might be released by the restore. */
  543. bool
  544. alloc_any_names_since_save(const alloc_save_t *save)
  545. {    return save->restore_names;
  546. }
  547.  
  548. /* Get the saved state with a given ID. */
  549. alloc_save_t *
  550. alloc_find_save(const gs_dual_memory_t *dmem, ulong sid)
  551. {    alloc_save_t *sprev = dmem->space_local->saved;
  552.     if ( sid == 0 )
  553.       return 0;        /* invalid id */
  554.     while ( sprev != 0 )
  555.     {    if ( sprev->id == sid )
  556.             return sprev;
  557.         sprev = sprev->state.saved;
  558.     }
  559.     return 0;
  560. }
  561.  
  562. /* Get the client data from a saved state. */
  563. void *
  564. alloc_save_client_data(const alloc_save_t *save)
  565. {    return save->client_data;
  566. }
  567.  
  568. /*
  569.  * Do one step of restoring the state.  The client is responsible for
  570.  * calling alloc_find_save to get the save object, and for ensuring that
  571.  * there are no surviving pointers for which alloc_is_since_save is true.
  572.  * Return true if the argument was the innermost save, in which case
  573.  * this is the last (or only) step.
  574.  * Note that "one step" may involve multiple internal steps,
  575.  * if this is the outermost restore (which requires restoring both local
  576.  * and global VM) or if we created extra save levels to reduce scanning.
  577.  */
  578. private void restore_finalize(P1(gs_ref_memory_t *));
  579. private void restore_space(P1(gs_ref_memory_t *));
  580. bool
  581. alloc_restore_state_step(alloc_save_t *save)
  582. {    gs_dual_memory_t *dmem = save->dmem;
  583.     gs_ref_memory_t *mem = dmem->space_local;
  584.     alloc_save_t *sprev;
  585.  
  586.     /* Do one (externally visible) step of restoring the state. */
  587.     do
  588.     {    ulong sid;
  589.         sprev = mem->saved;
  590.         sid = sprev->id;
  591.         restore_finalize(mem);        /* finalize objects */
  592.         restore_resources(sprev, mem);    /* release other resources */
  593.         restore_space(mem);        /* release memory */
  594.         if ( sid != 0 )
  595.           {    dmem->save_level--;
  596.             break;
  597.           }
  598.     }
  599.     while ( sprev != save );
  600.  
  601.     if ( dmem->save_level == 0 )
  602.     {    /* This is the outermost save, which might also */
  603.         /* need to restore global VM. */
  604.         mem = dmem->space_global;
  605.         if ( mem != dmem->space_local && mem->saved != 0 )
  606.           {    restore_finalize(mem);
  607.             restore_resources(mem->saved, mem);
  608.             restore_space(mem);
  609.           }
  610.         set_not_in_save(dmem);
  611.     }
  612.     else
  613.     {    /* Set the l_new attribute in all slots that are now new. */
  614.         save_set_new(mem, true);
  615.     }
  616.  
  617.     return sprev == save;
  618. }
  619. /* Restore the memory of one space, by undoing changes and freeing */
  620. /* memory allocated since the save. */
  621. private void
  622. restore_space(gs_ref_memory_t *mem)
  623. {    alloc_save_t *save = mem->saved;
  624.     alloc_save_t saved;
  625.  
  626.     print_save("restore", mem->space, save);
  627.  
  628.     /* Undo changes since the save. */
  629.     {    register alloc_change_t *cp = mem->changes;
  630.         while ( cp )
  631.           {
  632. #ifdef DEBUG
  633. if ( gs_debug_c('U') )
  634.             {    dprintf("[U]restore");
  635.             alloc_save_print(cp, true);
  636.             }
  637. #endif
  638.             if ( r_is_packed(&cp->contents) )
  639.               *cp->where = *(ref_packed *)&cp->contents;
  640.             else
  641.               ref_assign_inline((ref *)cp->where, &cp->contents);
  642.             cp = cp->next;
  643.           }
  644.     }
  645.  
  646.     /* Free memory allocated since the save. */
  647.     /* Note that this frees all chunks except the inner one */
  648.     /* belonging to this level. */
  649.     saved = *save;
  650.     restore_free(mem);
  651.  
  652.     /* Restore the allocator state. */
  653.     {    int num_contexts = mem->num_contexts;    /* don't restore */
  654.         *mem = saved.state;
  655.         mem->num_contexts = num_contexts;
  656.     }
  657.     alloc_open_chunk(mem);
  658.  
  659.     /* Make the allocator current if it was current before the save. */
  660.     if ( saved.is_current )
  661.       {    gs_dual_memory_t *dmem = saved.dmem;
  662.         dmem->current = mem;
  663.         dmem->current_space = mem->space;
  664.       }
  665. }
  666.  
  667. /* Restore to the initial state, releasing all resources. */
  668. /* The allocator is no longer usable after calling this routine! */
  669. void
  670. alloc_restore_all(gs_dual_memory_t *dmem)
  671. {
  672.     /* Restore to a state outside any saves. */
  673.     while ( dmem->save_level != 0 )
  674.       discard(alloc_restore_state_step(dmem->space_local->saved));
  675.  
  676.     /* Finalize memory. */
  677.     restore_finalize(dmem->space_local);
  678.     {    gs_ref_memory_t *mem = dmem->space_global;
  679.         if ( mem != dmem->space_local && mem->num_contexts == 1 )
  680.           restore_finalize(mem);
  681.     }
  682.     restore_finalize(dmem->space_system);
  683.  
  684.     /* Release resources other than memory, using fake */
  685.     /* save and memory objects. */
  686.     {    alloc_save_t empty_save;
  687.         empty_save.dmem = dmem;
  688.         empty_save.restore_names = false;    /* don't bother to release */
  689.         restore_resources(&empty_save, NULL);
  690.     }
  691.  
  692.     /* Finally, release memory. */
  693.     restore_free(dmem->space_local);
  694.     {    gs_ref_memory_t *mem = dmem->space_global;
  695.         if ( mem != dmem->space_local )
  696.         {    if ( !--(mem->num_contexts) )
  697.               restore_free(mem);
  698.         }
  699.     }
  700.     restore_free(dmem->space_system);
  701.  
  702. }
  703.  
  704. /*
  705.  * Finalize objects that will be freed by a restore.
  706.  * Note that we must temporarily disable the freeing operations
  707.  * of the allocator while doing this.
  708.  */
  709. private void
  710. restore_finalize(gs_ref_memory_t *mem)
  711. {    chunk_t *cp;
  712.  
  713.     alloc_close_chunk(mem);
  714.     gs_enable_free((gs_memory_t *)mem, false);
  715.     for ( cp = mem->clast; cp != 0; cp = cp->cprev )
  716.       {    SCAN_CHUNK_OBJECTS(cp)
  717.           DO_ALL
  718.             struct_proc_finalize((*finalize)) =
  719.               pre->o_type->finalize;
  720.             if ( finalize != 0 )
  721.               {    if_debug2('u', "[u]restore finalizing %s 0x%lx\n",
  722.                       struct_type_name_string(pre->o_type),
  723.                       (ulong)(pre + 1));
  724.                 (*finalize)(pre + 1);
  725.               }
  726.         END_OBJECTS_SCAN
  727.       }
  728.     gs_enable_free((gs_memory_t *)mem, true);
  729. }
  730.  
  731. /* Release resources for a restore */
  732. private void
  733. restore_resources(alloc_save_t *sprev, gs_ref_memory_t *mem)
  734. {
  735.     /* Close inaccessible files. */
  736.     file_restore(sprev, (const gs_memory_t *)mem);
  737.  
  738.     /* Remove entries from font and character caches. */
  739.     font_restore(sprev);
  740.  
  741.     /* Adjust the name table. */
  742.     if ( sprev->restore_names )
  743.       name_restore(sprev);
  744. }
  745.  
  746. /* Release memory for a restore. */
  747. private void
  748. restore_free(gs_ref_memory_t *mem)
  749. {    /* Free chunks allocated since the save. */
  750.     chunk_t *cp;
  751.     chunk_t *csucc;
  752.  
  753.     /* Free the chunks in reverse order, to encourage LIFO behavior. */
  754.     /* Don't free the chunk holding the allocator itself! */
  755.     for ( cp = mem->clast; cp != 0; cp = csucc )
  756.     {    csucc = cp->cprev;     /* save before freeing */
  757.         if ( cp->cbase + sizeof(obj_header_t) != (byte *)mem )
  758.           alloc_free_chunk(cp, mem);
  759.     }
  760. }
  761.  
  762. /* Forget a save, by merging this level with the next outer one. */
  763. private void combine_space(P1(gs_ref_memory_t *));
  764. private void forget_changes(P1(gs_ref_memory_t *));
  765. void
  766. alloc_forget_save(alloc_save_t *save)
  767. {    gs_dual_memory_t *dmem = save->dmem;
  768.     gs_ref_memory_t *mem = dmem->space_local;
  769.     alloc_save_t *sprev;
  770.  
  771.     print_save("forget_save", mem->space, save);
  772.  
  773.     /* Iteratively combine the current level with the previous one. */
  774.     do
  775.     {    sprev = mem->saved;
  776.         if ( sprev->id != 0 )
  777.           dmem->save_level--;
  778.         if ( dmem->save_level != 0 )
  779.           {    alloc_change_t *chp = mem->changes;
  780.             save_set_new(&sprev->state, true);
  781.             /* Concatenate the changes chains. */
  782.             if ( chp == 0 )
  783.               mem->changes = sprev->state.changes;
  784.             else
  785.               {    while ( chp->next != 0 )
  786.                   chp = chp->next;
  787.                 chp->next = sprev->state.changes;
  788.               }
  789.             file_forget_save(sprev);
  790.             combine_space(mem);    /* combine memory */
  791.           }
  792.         else
  793.           {    forget_changes(mem);
  794.             save_set_new(mem, false);
  795.             file_forget_save(sprev);
  796.             combine_space(mem);    /* combine memory */
  797.             /* This is the outermost save, which might also */
  798.             /* need to combine global VM. */
  799.             mem = dmem->space_global;
  800.             if ( mem != dmem->space_local && mem->saved != 0 )
  801.               {    forget_changes(mem);
  802.                 save_set_new(mem, false);
  803.                 combine_space(mem);
  804.               }
  805.             set_not_in_save(dmem);
  806.             break;            /* must be outermost */
  807.           }
  808.     }
  809.     while ( sprev != save );
  810. }
  811. /* Combine the chunks of the next outer level with those of the current one, */
  812. /* and free the bookkeeping structures. */
  813. private void
  814. combine_space(gs_ref_memory_t *mem)
  815. {    alloc_save_t *saved = mem->saved;
  816.     gs_ref_memory_t *omem = &saved->state;
  817.     chunk_t *cp;
  818.     chunk_t *csucc;
  819.  
  820.     alloc_close_chunk(mem);
  821.     for ( cp = mem->cfirst; cp != 0; cp = csucc )
  822.       {    csucc = cp->cnext;    /* save before relinking */
  823.         if ( cp->outer == 0 )
  824.           alloc_link_chunk(cp, omem);
  825.         else
  826.           {    chunk_t *outer = cp->outer;
  827.             outer->inner_count--;
  828.             if ( mem->pcc == cp )
  829.               mem->pcc = outer;
  830.             if ( mem->cfreed.cp == cp )
  831.               mem->cfreed.cp = outer;
  832.             /* "Free" the header of the inner chunk, */
  833.             /* and any immediately preceding gap left by */
  834.             /* the GC having compacted the outer chunk. */
  835.             { obj_header_t *hp = (obj_header_t *)outer->cbot;
  836.               hp->o_large = 0;
  837.               hp->o_size = (char *)(cp->chead + 1)
  838.                             - (char *)(hp + 1);
  839.               hp->o_type = &st_bytes;
  840.               /* The following call is probably not safe. */
  841. #if 0                /* **************** */
  842.                           gs_free_object((gs_memory_t *)mem,
  843.                                          hp + 1, "combine_space(header)");
  844. #endif                /* **************** */
  845.             }
  846.             /* Update the outer chunk's allocation pointers. */
  847.             outer->cbot = cp->cbot;
  848.             outer->rcur = cp->rcur;
  849.             outer->rtop = cp->rtop;
  850.             outer->ctop = cp->ctop;
  851.             outer->has_refs |= cp->has_refs;
  852.             gs_free_object(mem->parent, cp,
  853.                        "combine_space(inner)");
  854.           }
  855.       }
  856.     /* Update relevant parts of allocator state. */
  857.     mem->cfirst = omem->cfirst;
  858.     mem->clast = omem->clast;
  859.     mem->allocated += omem->allocated;
  860.     mem->gc_allocated += omem->allocated;
  861.     mem->lost.objects += omem->lost.objects;
  862.     mem->lost.refs += omem->lost.refs;
  863.     mem->lost.strings += omem->lost.strings;
  864.     mem->saved = omem->saved;
  865.     mem->previous_status = omem->previous_status;
  866.       {    /* Concatenate free lists. */
  867.         int i;
  868.         for ( i = 0; i < num_freelists; i++ )
  869.           {    obj_header_t *olist = omem->freelists[i];
  870.             obj_header_t *list = mem->freelists[i];
  871.             if ( olist == 0 )
  872.               ;
  873.             else if ( list == 0 )
  874.               mem->freelists[i] = olist;
  875.             else
  876.               {    while ( *(obj_header_t **)list != 0 )
  877.                   list = *(obj_header_t **)list;
  878.                 *(obj_header_t **)list = olist;
  879.               }
  880.           }
  881.       }
  882.     gs_free_object((gs_memory_t *)mem, saved, "combine_space(saved)");
  883.     alloc_open_chunk(mem);
  884. }
  885. /* Free the changes chain for a level 0 .forgetsave, */
  886. /* resetting the l_new flag in the changed refs. */
  887. private void
  888. forget_changes(gs_ref_memory_t *mem)
  889. {    register alloc_change_t *chp = mem->changes;
  890.     alloc_change_t *next;
  891.     for ( ; chp; chp = next )
  892.     {    ref_packed *prp = chp->where;
  893.         if_debug1('U', "[U]forgetting change 0x%lx\n", (ulong)chp);
  894.         if ( !r_is_packed(prp) )
  895.           r_clear_attrs((ref *)prp, l_new);
  896.         next = chp->next;
  897.         gs_free_object((gs_memory_t *)mem, chp, "forget_changes");
  898.     }
  899.     mem->changes = 0;
  900. }
  901.  
  902. /* ------ Internal routines ------ */
  903.  
  904. /* Set or reset the l_new attribute in every relevant slot. */
  905. /* This includes every slot on the current change chain, */
  906. /* and every (ref) slot allocated at this save level. */
  907. /* Return the number of bytes of data scanned. */
  908. private long
  909. save_set_new(gs_ref_memory_t *mem, bool to_new)
  910. {
  911.     long scanned = 0;
  912.  
  913.     /* Handle the change chain. */
  914.     save_set_new_changes(mem, to_new);
  915.  
  916.     /* Handle newly allocated ref objects. */
  917.     SCAN_MEM_CHUNKS(mem, cp)
  918.     { if ( cp->has_refs )
  919.       { bool has_refs = false;
  920.         SCAN_CHUNK_OBJECTS(cp)
  921.         DO_ALL
  922.           if_debug3('U', "[U]set_new scan(0x%lx(%lu), %d)\n",
  923.                 (ulong)pre, size, to_new);
  924.           if ( pre->o_type == &st_refs )
  925.            {    /* These are refs, scan them. */
  926.             ref_packed *prp = (ref_packed *)(pre + 1);
  927.             ref_packed *next = (ref_packed *)((char *)prp + size);
  928.             if_debug2('U', "[U]refs 0x%lx to 0x%lx\n",
  929.                   (ulong)prp, (ulong)next);
  930.             has_refs = true;
  931.             scanned += size;
  932.             /* We know that every block of refs ends with */
  933.             /* a full-size ref, so we only need the end check */
  934.             /* when we encounter one of those. */
  935. #define rp ((ref *)prp)
  936.             if ( to_new )
  937.               while ( 1 )
  938.                 {    if ( r_is_packed(prp) )
  939.                     prp++;
  940.                 else
  941.                 {    rp->tas.type_attrs |= l_new;
  942.                     prp += packed_per_ref;
  943.                     if ( prp >= next )
  944.                       break;
  945.                 }
  946.                 }
  947.             else
  948.               while ( 1 )
  949.                 {    if ( r_is_packed(prp) )
  950.                     prp++;
  951.                 else
  952.                 {    rp->tas.type_attrs &= ~l_new;
  953.                     prp += packed_per_ref;
  954.                     if ( prp >= next )
  955.                       break;
  956.                 }
  957.                 }
  958. #undef rp
  959.            }
  960.           else
  961.             scanned += sizeof(obj_header_t);
  962.         END_OBJECTS_SCAN
  963.         cp->has_refs = has_refs;
  964.       }
  965.     }
  966.     END_CHUNKS_SCAN
  967.     if_debug2('u', "[u]set_new (%s) scanned %ld\n",
  968.           (to_new ? "restore" : "save"), scanned);
  969.     return scanned;
  970. }
  971.  
  972. /* Set or reset the l_new attribute on the changes chain. */
  973. private void
  974. save_set_new_changes(gs_ref_memory_t *mem, bool to_new)
  975. {    register alloc_change_t *chp = mem->changes;
  976.     register uint new = (to_new ? l_new : 0);
  977.     for ( ; chp; chp = chp->next )
  978.     {    ref_packed *prp = chp->where;
  979.         if_debug2('U', "[U]set_new(0x%lx, %d)\n",
  980.               (ulong)prp, new);
  981.         if ( !r_is_packed(prp) )
  982. #define rp ((ref *)prp)
  983.          rp->tas.type_attrs =
  984.            (rp->tas.type_attrs & ~l_new) + new;
  985. #undef rp
  986.     }
  987. }
  988.